package _case

import "fmt"

func SimpleCase() {
	var num1, num2 = 10, 20
	var f1, f2 float32 = 8.88, 6.66
	fmt.Println("不使用泛型比较：", getMaxNumInt(num1, num2))
	fmt.Println("不使用泛型比较：", getMaxNumFloat(f1, f2))
	//由编译器推断输入的类型
	fmt.Println("使用泛型比较：", getMaxNum(num1, num2))
	//显式指定传入的类型
	fmt.Println("使用泛型比较：", getMaxNum[float32](f1, f2))
}

func CusNumCase() {
	var num1, num2 MyInt64 = 10, 20
	//var num int64 = num1 //报错：因为 MyInt64 和 int64 属于不同类型
	fmt.Println("使用自定义泛型比较：", getMaxCusNum(num1, num2))
	var f1, f2 float32 = 8.88, 6.66
	fmt.Println("使用自定义泛型比较：", getMaxCusNum[float32](f1, f2))
	var a, b MyInt32 = 10, 20
	fmt.Println("使用自定义泛型比较：", getMaxCusNum(a, b))
	var c, d uint8 = 10, 20
	fmt.Println("使用自定义泛型比较：", getMaxCusNums(c, d))
}

func getMaxNumInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func getMaxNumFloat(a, b float32) float32 {
	if a > b {
		return a
	}
	return b
}

// 由于 T *int | *float 会变成  T*int，所以实用interface{}包裹
// type MyStruct [T*int | *float]struct {
// }
type MyStruct[T interface{ *int | *float32 }] struct {
}

func getMaxNumInter[T interface{ int | float32 }](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// 泛型表示也可以用其它字母
func getMaxNumK[K int | float32](a, b K) K {
	if a > b {
		return a
	}
	return b
}
func getMaxNumH[h int | float32](a, b h) h {
	if a > b {
		return a
	}
	return b
}

func getMaxNum[T int | float32](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func getMaxCusNum[T CustomT](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func getMaxCusNums[T CustomTs](a, b T) T {
	if a > b {
		return a
	}
	return b
}

type CustomT interface {
	// 支持 int、uint8、int32、float32、int64等多种类型，以及int64衍生类型
	// ~表示支持类型的衍生类型
	// 单行 | 表示并集
	int | uint8 | int32 | float32 | ~int64
}

type CustomTs interface {
	// 支持 int、uint8、int32、float32、int64等多种类型，以及int64衍生类型
	// ~表示支持类型的衍生类型
	// 多行 | 表示交集
	int | uint8 | int32 | float32 | ~int64
	int64 | float64 | int | uint32 | uint8
}

// 为int64的衍生类型，具有类型int64的新类型，跟int64是不同类型
type MyInt64 int64

// 是int32的别名，与int32是同类型
type MyInt32 = int32

// 内置类型
func BuiltInCase() {
	var a, b = "abc", "df"
	fmt.Println("内置 comparable 泛型比较：", getBuiltInComparable(a, b))
	var c, d = 10, 10
	fmt.Println("内置 comparable 泛型比较：", getBuiltInComparable(c, d))

	var f = 3.34
	printBuiltInAny(a)
	printBuiltInAny(f)
}

// 用作比较的类型
func getBuiltInComparable[T comparable](a, b T) bool {
	if a == b {
		return true
	}
	return false
}

// 任意类型 相当于interface{}
func printBuiltInAny[T any](a T) {
	fmt.Println("内置 any 任意类型", a)
}
